// pages/chat/chat.ts
import { getConversationMessages, sendMessage as sendMessageAPI, getConversation, createConversation } from '../../utils/http/httpChat';
import { formatSmartTime } from '../../utils/DateTimeutil';

// 定义消息项的接口
interface MessageItem {
  id: number;
  type: 'text' | 'image' | 'audio';
  senderId: number;
  content: string;
  isFromMe: boolean;
  createTime: number;
  formatCreateTime: string;
  showTime?: boolean; // 是否显示创建时间（当与上一条消息间隔超过30分钟时显示）
  url?: string; // 图片或语音地址
  duration?: number; // 语音消息的时长（秒）
  isPlaying?: boolean; // 语音消息是否正在播放
  status: 'SENT' | 'SENDING' | 'FAILED';
}

Page({

  /**
   * 页面的初始数据
   */
  data: {
    conversationId: 0, // 会话ID
    workerId: 0, // 工人ID
    workerName: '', // 工人名称
    userId: 0, // 当前用户ID
    messageList: [] as MessageItem[], // 聊天消息列表
    inputMessage: '', // 输入框内容
    showMorePanel: false, // 是否显示更多功能面板
    scrollIntoView: '', // 滚动到指定消息
    isLoading: false, // 是否正在加载更多消息
    hasMoreMessages: true, // 是否还有更多历史消息
    pageSize: 20, // 每页消息数量
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 获取传递的参数
    const conversationId = parseInt(options.id || '0');
    this.setData({
      conversationId: conversationId,
      workerId: parseInt(options.workerId || '0') ,
      workerName: options.workerName || ''
    });

    // 获取当前用户信息
    this.getCurrentUserInfo();
    
    // 如果conversationId为空，则需要先获取会话信息
    if (conversationId === 0) {
      this.getOrCreateConversation();
    } else {
      // 有conversationId，直接加载聊天数据
      this.loadChatMessage();
    }
  },

  /**
   * 获取当前用户信息
   */
  getCurrentUserInfo() {
    // 直接从本地存储获取用户信息，避免重复调用接口
    const userInfo = wx.getStorageSync('userInfo');
    
    if (userInfo && userInfo.id) {
      // 从本地存储成功获取用户ID
      this.setData({
        userId: userInfo.id
      });
      console.log('从本地存储获取用户ID:', userInfo.id);
    } else {
      // 本地存储中没有用户信息，使用默认值
      console.warn('本地存储中未找到用户信息，使用默认用户ID');
      this.setData({
        userId: -1 // 使用默认用户ID
      });
    }
  },

  /**
   * 获取或创建会话
   */
  getOrCreateConversation() {
    const { userId, workerId } = this.data;

    if (userId === -1) {
      console.error('用户ID为空，用户未登录');
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    if (!workerId) {
      console.error('工人ID不能为空');
      wx.showToast({
        title: '工人信息错误',
        icon: 'none'
      });
      return;
    }
    console.log('尝试获取会话，userId:', userId, 'workerId:', workerId);

    // 调用接口获取会话信息
    getConversation(userId, workerId).then(response => {
      if (response.code === 200 && response.data) {
        // 成功获取到会话信息
        const conversationId = response.data.conversationId;
        console.log('成功获取会话ID:', conversationId);
        
        this.setData({
          conversationId: conversationId
        });
        
        // 获取到会话ID后，加载聊天消息
        this.loadChatMessage();
      } else {
        // 没有找到会话，保持conversationId为0，不加载消息
        console.log('未找到会话，conversationId保持为0');
        this.setData({
          conversationId: 0,
          messageList: []
        });
      }
    }).catch(error => {
      console.error('获取会话信息异常:', error);
      // 发生异常时，保持conversationId为0，不加载消息
      this.setData({
        conversationId: 0,
        messageList: []
      });
      wx.showToast({
        title: '获取会话信息失败',
        icon: 'none'
      });
    });
  },

  /**
   * 加载聊天数据
   */
  loadChatMessage() {
    const { conversationId, userId } = this.data;
    
    if (!conversationId) {
      console.error('会话ID不能为空');
      return;
    }

    if (userId == -1) {
      console.error('用户ID为空，用户未登录');
      return;
    }

    this.setData({
      isLoading: true
    });

    // 调用真实接口获取消息列表
    getConversationMessages(conversationId, {
      pageNum: 1,
      pageSize: this.data.pageSize
    }).then(response => {
      if (response.code === 200) {
        const messages = response.rows || [];
        
        // 将服务器返回的Message转换为MessageItem
        const messageItems: MessageItem[] = messages.map(msg => {
          const messageType = this.convertMessageType(msg.messageType);
          return {
            id: msg.messageId,
            type: messageType,
            senderId: msg.senderId,
            content: msg.content,
            isFromMe: msg.senderId === userId,
            createTime: new Date(msg.createTime).getTime(),
            formatCreateTime: formatSmartTime(new Date(msg.createTime).getTime(), 'chat'),
            url: msg.mediaUrl || undefined,
            duration: msg.mediaDuration || undefined,
            status: 'SENT' as const
          };
        });

        // 按创建时间排序，确保最新消息在底部
        messageItems.sort((a, b) => a.createTime - b.createTime);

        // 处理消息时间显示
        const processedMessages = this.processMessageTimeDisplay(messageItems);

        // 判断是否还有更多消息
        const hasMore = response.total > this.data.pageSize;

        this.setData({
          messageList: processedMessages,
          hasMoreMessages: hasMore,
          isLoading: false,
          scrollIntoView: processedMessages.length > 0 ? `msg-${processedMessages[processedMessages.length - 1].id}` : ''
        });
      } else {
        console.error('获取消息列表失败:', response.msg);
        this.setData({
          isLoading: false
        });
        wx.showToast({
          title: response.msg || '获取消息失败',
          icon: 'none'
        });
      }
    }).catch(error => {
      console.error('获取消息列表异常:', error);
      this.setData({
        isLoading: false
      });
      wx.showToast({
        title: '网络异常，请稍后重试',
        icon: 'none'
      });
    });
  },

  /**
   * 转换消息类型
   */
  convertMessageType(messageType: number): 'text' | 'image' | 'audio' {
    switch (messageType) {
      case 1:
        return 'text';
      case 2:
        return 'image';
      case 3:
        return 'audio';
      default:
        return 'text';
    }
  },

  /**
   * 处理消息时间显示逻辑
   * 如果与上一条消息间隔超过30分钟，则显示时间
   */
  processMessageTimeDisplay(messages: MessageItem[]): MessageItem[] {
    if (messages.length === 0) return messages;
    
    const processedMessages = messages.slice();
    const thirtyMinutes = 30 * 60 * 1000; // 30分钟的毫秒数
    
    // 第一条消息总是显示时间
    processedMessages[0].showTime = true;
    
    // 处理后续消息
    for (let i = 1; i < processedMessages.length; i++) {
      const currentMsg = processedMessages[i];
      const prevMsg = processedMessages[i - 1];
      
      // 如果当前消息与上一条消息的时间间隔超过30分钟，则显示时间
      if (currentMsg.createTime - prevMsg.createTime > thirtyMinutes) {
        currentMsg.showTime = true;
      } else {
        currentMsg.showTime = false;
      }
    }
    
    return processedMessages;
  },

  /**
   * 处理单条新消息的时间显示
   */
  processSingleMessageTimeDisplay(newMessage: MessageItem, previousMessage?: MessageItem): MessageItem {
    const thirtyMinutes = 30 * 60 * 1000; // 30分钟的毫秒数
    
    // 如果没有前一条消息，或者时间间隔超过30分钟，则显示时间
    if (!previousMessage || newMessage.createTime - previousMessage.createTime > thirtyMinutes) {
      newMessage.showTime = true;
    } else {
      newMessage.showTime = false;
    }
    
    return newMessage;
  },

  /**
   * 返回上一页
   */
  goBack() {
    wx.navigateBack({
      fail: () => {
        wx.switchTab({
          url: '/pages/message/message'
        });
      }
    });
  },

  /**
   * 输入框内容变化
   */
  onInputChange(e: WechatMiniprogram.Input) {
    const value = e.detail.value;
    
    // 更新输入内容
    this.setData({
      inputMessage: value
    });
    
    // 单行输入框不需要检测回车键，因为会触发bindconfirm事件
  },

  /**
   * 发送消息
   */
  sendMessage() {
    const { inputMessage, messageList, conversationId, userId, workerId } = this.data;
    
    if (!inputMessage.trim()) return;
    
    // 检查conversationId是否为0，如果为0则需要先创建会话
    if (conversationId === 0) {
      this.createConversationAndSendMessage(inputMessage.trim());
      return;
    }
    
    this.doSendMessage(inputMessage.trim(), conversationId);
  },

  /**
   * 创建会话并发送消息
   */
  createConversationAndSendMessage(messageContent: string) {
    const { userId, workerId } = this.data;
    
    if (userId === -1) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }

    if (!workerId) {
      wx.showToast({
        title: '工人信息错误',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '创建会话中...'
    });

    // 调用创建会话接口
    createConversation(userId, workerId).then(response => {
      wx.hideLoading();
      
      if (response.code === 200 && response.data) {
        // 创建会话成功，保存conversationId
        const newConversationId = response.data.conversationId;
        console.log('成功创建会话ID:', newConversationId);
        
        this.setData({
          conversationId: newConversationId
        });
        
        // 创建会话成功后，发送消息
        this.doSendMessage(messageContent, newConversationId);
      } else {
        wx.showToast({
          title: response.msg || '创建会话失败',
          icon: 'none'
        });
      }
    }).catch(error => {
      wx.hideLoading();
      console.error('创建会话异常:', error);
      wx.showToast({
        title: '网络异常，创建会话失败',
        icon: 'none'
      });
    });
  },

  /**
   * 执行发送消息
   */
  doSendMessage(messageContent: string, conversationId: number) {
    const { messageList, userId } = this.data;
    
    const now = Date.now();
    const tempId = Date.now(); // 使用时间戳作为临时ID
    
    // 先在界面上显示发送中的消息
    const newMessage: MessageItem = {
      id: tempId,
      type: 'text',
      content: messageContent,
      isFromMe: true,
      createTime: now,
      senderId: userId,
      formatCreateTime: formatSmartTime(now, 'chat'),
      status: 'SENDING'
    };
    
    // 获取最后一条消息，用于判断时间显示
    const lastMessage = messageList.length > 0 ? messageList[messageList.length - 1] : undefined;
    
    // 处理新消息的时间显示
    const processedNewMessage = this.processSingleMessageTimeDisplay(newMessage, lastMessage);
    
    const updatedMessages = messageList.concat([processedNewMessage]);
    
    // 清空输入框并滚动到最新消息
    this.setData({
      inputMessage: '',
      messageList: updatedMessages,
      scrollIntoView: `msg-${tempId}`
    });

    // 调用发送消息接口
    sendMessageAPI(conversationId, {
      conversationId: conversationId,
      messageType: 1, // 文本消息
      content: messageContent
    }).then(response => {
      if (response.code === 200 && response.data) {
        // 发送成功，使用服务器返回的消息数据更新本地消息
        const serverMessage = response.data;
        const currentMessages = this.data.messageList;
        const messageIndex = currentMessages.findIndex(msg => msg.id === tempId);
        
        if (messageIndex !== -1) {
          const updatedMessages = currentMessages.slice();
          
          // 使用服务器返回的数据更新消息
          const updatedMessage: MessageItem = {
            id: serverMessage.messageId,
            type: this.convertMessageType(serverMessage.messageType),
            content: serverMessage.content,
            isFromMe: serverMessage.senderId === userId,
            createTime: new Date(serverMessage.createTime).getTime(),
            senderId: serverMessage.senderId,
            formatCreateTime: formatSmartTime(new Date(serverMessage.createTime).getTime(), 'chat'),
            url: serverMessage.mediaUrl || undefined,
            duration: serverMessage.mediaDuration || undefined,
            status: 'SENT'
          };
          
          // 获取前一条消息，用于判断时间显示
          const previousMessage = messageIndex > 0 ? updatedMessages[messageIndex - 1] : undefined;
          
          // 处理更新消息的时间显示
          const processedMessage = this.processSingleMessageTimeDisplay(updatedMessage, previousMessage);
          
          updatedMessages[messageIndex] = processedMessage;
          
          this.setData({
            messageList: updatedMessages,
            scrollIntoView: `msg-${serverMessage.messageId}`
          });
        }
        
      } else {
        // 发送失败，更新消息状态
        const currentMessages = this.data.messageList;
        const messageIndex = currentMessages.findIndex(msg => msg.id === tempId);
        
        if (messageIndex !== -1) {
          const updatedMessages = currentMessages.slice();
          updatedMessages[messageIndex].status = 'FAILED';
          
          this.setData({
            messageList: updatedMessages
          });
        }
        
        wx.showToast({
          title: response.msg || '发送失败',
          icon: 'none'
        });
      }
    }).catch(error => {
      console.error('发送消息异常:', error);
      
      // 发送失败，更新消息状态
      const currentMessages = this.data.messageList;
      const messageIndex = currentMessages.findIndex(msg => msg.id === tempId);
      
      if (messageIndex !== -1) {
        const updatedMessages = currentMessages.slice();
        updatedMessages[messageIndex].status = 'FAILED';
        
        this.setData({
          messageList: updatedMessages
        });
      }
      
      wx.showToast({
        title: '网络异常，发送失败',
        icon: 'none'
      });
    });
  },

  /**
   * 切换更多功能面板
   */
  toggleMorePanel() {
    this.setData({
      showMorePanel: !this.data.showMorePanel
    });
  },

  /**
   * 隐藏更多功能面板
   */
  hideMorePanel() {
    this.setData({
      showMorePanel: false
    });
  },

  /**
   * 处理面板项点击
   */
  onPanelItemTap(e: WechatMiniprogram.TouchEvent) {
    const type = e.currentTarget.dataset.type;
    
    // 关闭面板
    this.hideMorePanel();
    
    // 提示功能暂不支持
    wx.showToast({
      title: `${type === 'album' ? '相册' : type === 'camera' ? '拍摄' : '语音'}功能暂不支持`,
      icon: 'none'
    });
  },

  /**
   * 预览图片
   */
  previewImage(e: WechatMiniprogram.TouchEvent) {
    const src = e.currentTarget.dataset.src;
    wx.previewImage({
      current: src,
      urls: [src]
    });
  },

  /**
   * 播放语音
   */
  playAudio(e: WechatMiniprogram.TouchEvent) {
    const id = e.currentTarget.dataset.id;
    const { messageList } = this.data;
    
    // 找到对应的语音消息
    const audioIndex = messageList.findIndex(msg => msg.id === id);
    
    if (audioIndex !== -1) {
      // 更新播放状态
      const updatedMessages = messageList.slice();
      updatedMessages[audioIndex].isPlaying = true;
      
      this.setData({
        messageList: updatedMessages
      });
      
      // 模拟播放结束
      setTimeout(() => {
        updatedMessages[audioIndex].isPlaying = false;
        this.setData({
          messageList: updatedMessages
        });
      }, updatedMessages[audioIndex].duration! * 1000);
      
      // 提示功能暂不支持
      wx.showToast({
        title: '语音播放功能暂不支持',
        icon: 'none'
      });
    }
  },

  /**
   * 加载更多历史消息
   */
  loadMoreMessages() {
    const { messageList, conversationId, userId, hasMoreMessages, isLoading, pageSize } = this.data;
    
    // 如果消息列表为空，直接返回
    if (messageList.length === 0) {
      return;
    }
    // 如果正在加载或没有更多消息，则不执行
    if (isLoading || !hasMoreMessages) {
      wx.showToast({
        title: '没有更多历史消息',
        icon: 'none'
      });
      return;
    }

    // 获取最早消息的ID作为lastMsgId
    const lastMsgId = messageList.length > 0 ? messageList[0].id : undefined;
    
    this.setData({
      isLoading: true
    });

    // 调用接口加载更多消息
    getConversationMessages(conversationId, {
      lastMsgId: lastMsgId,
      pageNum: 1,
      pageSize: pageSize
    }).then(response => {
      if (response.code === 200) {
        const messages = response.rows || [];
        
        if (messages.length === 0) {
          // 没有更多消息
          this.setData({
            hasMoreMessages: false,
            isLoading: false
          });
          wx.showToast({
            title: '没有更多历史消息',
            icon: 'none'
          });
          return;
        }

        // 将服务器返回的Message转换为MessageItem
        const newMessageItems: MessageItem[] = messages.map(msg => {
          const messageType = this.convertMessageType(msg.messageType);
          return {
            id: msg.messageId,
            type: messageType,
            senderId: msg.senderId,
            content: msg.content,
            isFromMe: msg.senderId === userId,
            createTime: new Date(msg.createTime).getTime(),
            formatCreateTime: formatSmartTime(new Date(msg.createTime).getTime(), 'chat'),
            url: msg.mediaUrl || undefined,
            duration: msg.mediaDuration || undefined,
            status: 'SENT' as const
          };
        });

        // 按创建时间排序
        newMessageItems.sort((a, b) => a.createTime - b.createTime);

        // 将新消息添加到现有消息列表的前面
        const allMessages = [...newMessageItems, ...messageList];

        // 处理消息时间显示
        const processedMessages = this.processMessageTimeDisplay(allMessages);

        // 判断是否还有更多消息
        const hasMore = messages.length === pageSize;

        this.setData({
          messageList: processedMessages,
          hasMoreMessages: hasMore,
          isLoading: false
        });

        wx.showToast({
          title: `加载了${messages.length}条历史消息`,
          icon: 'success'
        });
      } else {
        console.error('加载更多消息失败:', response.msg);
        this.setData({
          isLoading: false
        });
        wx.showToast({
          title: response.msg || '加载失败',
          icon: 'none'
        });
      }
    }).catch(error => {
      console.error('加载更多消息异常:', error);
      this.setData({
        isLoading: false
      });
      wx.showToast({
        title: '网络异常，请稍后重试',
        icon: 'none'
      });
    });
  },

  /**
   * 处理键盘高度变化
   */
  onKeyboardHeightChange(e: WechatMiniprogram.Input) {
    // 键盘高度变化时，滚动到最新消息
    const { messageList } = this.data;
    if (messageList.length > 0) {
      this.setData({
        scrollIntoView: `msg-${messageList[messageList.length - 1].id}`
      });
    }
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 由于使用了自定义导航栏，不需要设置导航栏标题
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    // 模拟加载更多历史消息
    this.loadMoreMessages();
    setTimeout(() => {
      wx.stopPullDownRefresh();
    }, 1000);
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    return {
      title: `与${this.data.workerName}的聊天`,
      path: `/pages/chat/chat?workerId=${this.data.workerId}&workerName=${this.data.workerName}`,
      imageUrl: '/miniprogram/images/worker.png'
    };
  }
})